Java并发编程原理与实战五：创建线程的多种方式
一、继承Thread类
public class Demo1 extends Thread { public Demo1(String name) { super(name); } @Override public void run() { while(!interrupted()) { System.out.println(getName() + "线程执行了 .. "); try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) { Demo1 d1 = new Demo1("first-thread"); Demo1 d2 = new Demo1("second-thread"); d1.start(); d2.start(); // d1.stop(); d1.interrupt(); } }
二、实现Runnable 接口
/** * 作为线程任务存在 * * @author worker * */ public class Demo2 implements Runnable { @Override public void run() { while(true) { System.out.println("thread running ..."); } } public static void main(String[] args) { Thread thread = new Thread(new Demo2()); thread.start(); } }
三、匿名内部类的方式
public class Demo3 { public static void main(String[] args) { /*new Thread() { public void run() { System.out.println("thread start .."); }; }.start();*/ /*new Thread(new Runnable() { @Override public void run() { System.out.println("thread start .."); } }).start();*/ new Thread(new Runnable() { @Override public void run() { System.out.println("runnable"); } }) { public void run() { System.out.println("sub"); }; }.start(); } }
四、带返回值的线程
import java.util.concurrent.Callable; import java.util.concurrent.FutureTask; public class Demo4 implements Callable<Integer> { public static void main(String[] args) throws Exception { Demo4 d = new Demo4(); FutureTask<Integer> task = new FutureTask<>(d); Thread t = new Thread(task); t.start(); System.out.println("我先干点别的。。。"); Integer result = task.get(); System.out.println("线程执行的结果为：" + result); } @Override public Integer call() throws Exception { System.out.println("正在进行紧张的计算...."); Thread.sleep(3000); return 1; } }
五、定时器
import java.util.Timer; import java.util.TimerTask; public class Demo5 { public static void main(String[] args) { Timer timer = new Timer(); timer.schedule(new TimerTask() { @Override public void run() { // 实现定时任务 System.out.println("timertask is run"); } }, 0, 1000); } }
六、线程池的实现
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Demo6 { public static void main(String[] args) { ExecutorService threadPool = Executors.newCachedThreadPool(); for (int i = 0; i < 1000; i++) { threadPool.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()); } }); } threadPool.shutdown(); } }
七、Lambda表达式实现
import java.util.Arrays; import java.util.List; public class Demo7 { public static void main(String[] args) { List<Integer> values = Arrays.asList(10,20,30,40); int res = new Demo7().add(values); System.out.println("计算的结果为：" + res); } public int add (List<Integer> values) { // values.parallelStream().forEach(System.out :: println); return values.parallelStream().mapToInt( i -> i * 2).sum(); } }
八、Spring实现多线程
spring通过任务执行器TaskExecutor来实现多线程与并发编程。通常使用ThreadPoolTaskExecutor来实现一个基于线程池的TaskExecutor.
首先你要实现AsyncConfigurer 这个接口，目的是开启一个线程池.
import java.util.concurrent.Executor; import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.AsyncConfigurer; import org.springframework.scheduling.annotation.EnableAsync; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; /** * 注入一个线程池 * @author mingge * */ @Configuration @ComponentScan("com.foreveross.service.weixin.test.thread") @EnableAsync public class TaskExecutorConfig implements AsyncConfigurer { @Override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor taskExecutor=new ThreadPoolTaskExecutor(); taskExecutor.setCorePoolSize(5); taskExecutor.setMaxPoolSize(20); taskExecutor.setQueueCapacity(25); taskExecutor.initialize(); return taskExecutor; } @Override public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { return null; } }
然后注入一个类，实现你的业务，并在你的Bean的方法中使用@Async注解来声明其是一个异步任务
import org.springframework.scheduling.annotation.Async; import org.springframework.stereotype.Service; /** * 线程池任务 * @author mingge * */ @Service public class TaskService { @Async public void executeAsyncTask(int i){ System.out.println("执行异步任务:"+i); } @Async public void executeAsyncTask1(int i){ System.out.println("执行异步任务1:"+(i+i)); } }
最后通过测试，可以看到你的实现是异步执行了.
import org.springframework.context.annotation.AnnotationConfigApplicationContext; /** * * @author mingge * */ public class Test { public static void main(String[] args) { AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(TaskExecutorConfig.class); TaskService taskService=context.getBean(TaskService.class); for(int i=0;i<20;i++){ taskService.executeAsyncTask(i); taskService.executeAsyncTask1(i); } //最后可以根据结果可以看出结果是并发执行而不是顺序执行的呢 context.close(); } }
方式二：XML方式
spring就提供了ThreadPoolTaskExecutor这个类来实现线程池，线程池是啥，可以理解为数据源，或者有一堆线程的池子也行
在spring配置中我们可以写好如下代码（大致意思都在注释中，不多说了，百度也一堆）：
<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"> <!-- 核心线程数 --> <property name="corePoolSize" value="5" /> <!-- 最大线程数 --> <property name="maxPoolSize" value="10" /> <!-- 队列最大长度 >=mainExecutor.maxSize --> <property name="queueCapacity" value="25" /> <!-- 线程池维护线程所允许的空闲时间 --> <property name="keepAliveSeconds" value="3000" /> <!-- 线程池对拒绝任务(无线程可用)的处理策略 ThreadPoolExecutor.CallerRunsPolicy策略 ,调用者的线程会执行该任务,如果执行器已关闭,则丢弃. --> <property name="rejectedExecutionHandler"> <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" /> </property> </bean>
然后定义一个component组件，然后线程的引用就十分简单了，只要把这个线程扔进这个线程池子就行了
@Component public class FileCutter { @Autowired private TaskExecutor taskExecutor; public void filesMng(String path, String fileName) { this.taskExecutor.execute(new CutFilesThread(path,fileName)); } private class CutFilesThread implements Runnable { private String path; private String fileName; private CutFilesThread(String path, String fileName) { super(); this.path = path; this.fileName = fileName; } @Override public void run() { System.out.println("barry... run..."); // display(path, fileName); } }
最后在你所需要的地方就可以调用这个组件了，不论是service还是controller都行
@Autowired private FileCutter fileCutter; @RequestMapping("/cut") @ResponseBody public Object cut(){ fileCutter.filesMng("your path", "your fileName"); return "success"; }
另外可以参考：https://blog.csdn.net/king_kgh/article/details/76022136
参考资料：
龙果学院《Java并发编程原理与实战》
